// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({
  env: 'cake-shop-001-gppbo'
})

const db = cloud.database()
const _ = db.command

//引用TcbRouter
const TcbRouter = require('tcb-router')

// 成功的数据结构
const getSuccessData = (data = {}) => ({
  status: 200,
  data: {
    status: 0,
    data
  }
})

// 失败的数据结构
// {
//   status: 1,
//   msg: '获取 index_nav category中的分类 异常, 请重新尝试',
// }
const getFailData = (data = {}) => ({
  status: 401,
  data: {
    ...data
  }
})

/*
得到指定数组的分页信息对象
 */
const pageFilter = (arr, pageNum, pageSize) => {
  pageNum = pageNum * 1
  pageSize = pageSize * 1

  const total = arr.length
  const pages = Math.floor((total + pageSize - 1) / pageSize)
  const start = pageSize * (pageNum - 1)
  const end = start + pageSize <= total ? start + pageSize : total
  const list = []

  for (var i = start; i < end; i++) {
    list.push(arr[i])
  }

  return {
    pageNum,
    total,
    pages,
    pageSize,
    list
  }
}

// 云函数入口函数
exports.main = async (event, context) => {
  const app = new TcbRouter({
    event
  })

  /**
   * 获取所有一级二级的品类列表
   */
  app.router('/category/list', async (ctx, next) => {
    let {
      parentId
    } = event.other

    parentId = parentId + ''

    if ('decoration' === parentId) {
      // 获取装修种类下面的所有分类
      parentId = '5df0e327cdaeae3670403134'
    } else if ('other' === parentId) {
      // 获取其他种类下面的所有分类
      parentId = '5df2097206c387360c5c29a0'
    }

    try {
      // 获取产品
      const {
        data
      } = await db.collection("categorys").where({
        parentId
      }).get()

      // 这是为了适应原来的admin页面的结构
      ctx.body = getSuccessData(data)

    } catch (error) {
      ctx.body = getFailData({
        status: 1,
        msg: '获取分类列表异常, 请重新尝试。',
        error
      })
    }
  })

  /**
   * 获取走进永昌的导航栏的图片、名字等。
   */
  app.router('/category/navInfo', async (ctx, next) => {
    // 这是 走进永昌 分类的id
    const parentId = '5de31d24b0f80726901430c9'
    // 过滤掉 轮播图 的id
    const filterId = '5de328e2e887230e08f4fdf8'

    try {
      const {
        data: result
      } = await db.collection("categorys").where({
        parentId
      }).get()

      // 这里要 转化为string类型
      const newRestult = result
        .filter((item) => item._id + '' !== filterId)
        .map((item) => ({
          name: item.name,
          image: ''
        }))

      ctx.body = getSuccessData(newRestult)

    } catch (error) {
      ctx.body = getFailData({
        status: 1,
        msg: '获取 index_nav category中的分类 异常, 请重新尝试',
        error
      })
    }
  })

  /**
   * 更新分类
   */
  app.router('/category/update', async (ctx, next) => {
    const {
      categoryId,
      categoryName
    } = event.other

    // 更新集合 categorys 中的分类名字
    try {
      await db.collection("categorys")
        .where({
          _id: categoryId
        })
        .update({
          data: {
            name: categoryName
          }
        })

      /**
       * 查看当前更新的分类名字是一级还是二级分类，
       * 然后更新products对应的 cascaderText
       */
      try {
        const {
          data: dataCategorys
        } = await db.collection("categorys").where({
          _id: categoryId
        }).get()

        // 这里表示没有这个分类
        if (dataCategorys.length <= 0) {
          ctx.body = getSuccessData({
            dataCategorys,
            msg: 'categorys 没有这个分类'
          })
        }

        // 如果是一级分类那么：parentId === "0"
        const {
          parentId
        } = dataCategorys[0]

        const flagParentId = parentId + '' === "0"
        // 确定好在集合 products 中的查找条件，如果是二级分类就查找categoryId，如果是一级就查找 pCategoryId
        const conditionFind = flagParentId ? {
          pCategoryId: categoryId
        } : {
          categoryId
        }

        // 开始在集合 products 中查找
        const {
          data: dataProducts
        } = await db.collection("products").where(conditionFind)
          .get()

        // ctx.body = getSuccessData({
        //   dataProducts,
        //   msg: "测试111"
        // })

        // 小于等于0 表示没有数据
        if (dataProducts.length <= 0) {
          ctx.body = getSuccessData({
            dataProducts,
            msg: '没有数据'
          })
        }

        // 这里尝试使用“聚合”，生成 cascaderText。聚合用不了啊！

        // 开始修改 cascaderText 
        dataProducts.forEach(async (item) => {

          // 确定好查找条件和更新的文字
          let conditionUpdate, names, newCascaderText

          // 根据分类，确定一些条件。

          names = item.cascaderText.split('/')
          // newCascaderText = flagParentId ? `${names[0]}/${categoryName}` : `${categoryName}/${names[1]}`
          newCascaderText = flagParentId ? `${categoryName}/${names[1]}` : `${names[0]}/${categoryName}`

          // 这是更新的条件
          conditionUpdate = {
            cascaderText: newCascaderText
          }

          // 查找并且更新
          try {

            await db.collection("products")
              .where(conditionFind)
              .update({
                data: conditionUpdate
              })

          } catch (error) {

            ctx.body = getFailData({
              status: 1,
              msg: '更新二级分类的cascaderText',
              error
            })

          }

        })

        ctx.body = getSuccessData()

      } catch (error) {
        ctx.body = getFailData({
          status: 1,
          msg: '查找分类异常, 请重新尝试',
          error
        })
      }

    } catch (error) {

      ctx.body = getFailData({
        status: 1,
        msg: '更新分类名称异常, 请重新尝试',
        error
      })

    }

  })

  /**
   * 添加分类
   */
  app.router('/category/add', async (ctx, next) => {
    const {
      categoryName,
      parentId
    } = event.other

    const dataObj = {
      name: categoryName,
      parentId: parentId || '0'
    }

    // 检查同一个分类id下，该分类名字是否重复
    try {
      const resultCount = await db.collection("categorys").where({
        parentId
      }).count()

      if (resultCount > 0)
        ctx.body = getFailData({
          status: 1,
          msg: '该分类名已经存在, 请重新尝试'
        })
      else {
        try {
          await db.collection("categorys").add({
            data: {
              ...dataObj
            }
          })

          ctx.body = getSuccessData()

        } catch (error) {

          ctx.body = getFailData({
            status: 1,
            msg: '添加分类异常, 请重新尝试',
            error,
            dataObj
          })

        }
      }

    } catch (error) {
      ctx.body = getFailData({
        status: 1,
        msg: '新增分类失败',
        error: error
      })
    }

  })

  /**
   * 搜索商品分页列表
   * 这个用来初始化 product 页面
   */
  app.router('/product/list', async (ctx, next) => {
    const {
      pageNum,
      pageSize
    } = event.other

    try {
      const {
        data: result
      } = await db.collection('products')
        .orderBy('lastTime', 'desc')
        .orderBy('messagesId', 'desc')
        .get()

      const data = pageFilter(result, pageNum, pageSize)

      ctx.body = getSuccessData(data)

    } catch (error) {

      ctx.body = getFailData({
        status: 1,
        msg: '获取商品列表异常, 请重新尝试',
        error
      })

    }
  })

  /**
   * 添加文章信息
   */
  app.router('/product/add', async (ctx, next) => {
    const {
      product
    } = event.other

    try {
      const {
        data
      } = await db.collection("products").add({
        data: {
          ...product
        }
      })

      ctx.body = getSuccessData()
    } catch (error) {
      ctx.body = getFailData({
        status: 1,
        msg: '添加文章错误',
        error
      })
    }
  })

  /**
   * 修改文章信息
   */
  app.router('/product/update', async (ctx, next) => {
    let {
      product
    } = event.other

    const {
      product: {
        _id
      }
    } = event.other

    delete product._id

    try {
      const result = await db.collection("products").where({
        _id
      }).update({
        data: {
          ...product
        }
      })

      ctx.body = getSuccessData(product)

    } catch (error) {

      ctx.body = getFailData({
        status: 1,
        msg: '更新文章错误',
        error,
      })

    }
  })

  /**
   * 搜索商品分页列表
   */
  app.router('/product/search', async (ctx, next) => {
    const {
      pageNum,
      pageSize,
      searchName,
      searchType
    } = event.other

    let condition

    // 如果是按照关键字搜索
    if (searchName) {
      condition = {
        title: db.RegExp({
          regexp: `^.*${searchName}.*$`,
          options: 'i',
        })
      }
      // 如果是按照分类搜索
    } else if (searchType) {
      const {
        categoryId,
        pCategoryId
      } = searchType

      if (undefined !== categoryId && undefined !== pCategoryId) {

        condition = {
          categoryId: db.RegExp({
            regexp: `^.*${categoryId}.*$`,
            options: 'i',
          }),
          pCategoryId: db.RegExp({
            regexp: `^.*${pCategoryId}.*$`,
            options: 'i',
          })
        }

      } else if (undefined !== pCategoryId && undefined === categoryId) {

        condition = {
          pCategoryId: db.RegExp({
            regexp: `^.*${pCategoryId}.*$`,
            options: 'i',
          })
        }

      }

    }

    try {

      const {
        total
      } = await db.collection("products")
        .where({
          ...condition
        })
        .count()

      const {
        data: list
      } = await db.collection("products")
        .where({
          ...condition
        })
        .skip((pageNum - 1) * pageSize)
        .limit(pageSize)
        .orderBy('lastTime', 'desc')
        .get()

      ctx.body = getSuccessData({
        pageNum,
        total,
        pages: Math.ceil(total / pageSize),
        pageSize,
        list,
        searchType
      })

    } catch (error) {

      ctx.body = getFailData({
        status: 1,
        msg: '搜索商品列表异常, 请重新尝试',
        error
      })

    }
  })

  /**
   * 对商品进行上架/下架处理
   */
  app.router('/product/updateStatus', async (ctx, next) => {
    const {
      productId,
      status,
    } = event.other

    let msg = {
      status: 1,
      msg: '更新产品状态异常, 请重新尝试'
    }

    if (1 === status * 1 || 2 === status * 1) {

      try {
        await db.collection("products")
          .where({
            _id: productId
          })
          .update({
            data: {
              status
            }
          })

        ctx.body = getSuccessData()

      } catch (error) {

        ctx.body = getFailData({
          ...msg,
          error
        })

      }

    } else {

      ctx.body = getFailData({
        ...msg
      })

    }
  })

  /**
   * 删除文章
   */
  app.router('/product/delete', async (ctx, next) => {
    const {
      _id
    } = event.other

    try {
      const result = await db.collection('products').doc(_id).remove()
      ctx.body = getSuccessData()
    } catch (e) {
      ctx.body = getFailData({
        status: 1,
        msg: '删除文章错误',
        error: e
      })
    }
  })

  /**
   * 删除照片
   * 这里要对数组操作，
   */
  app.router('/img/delete', async (ctx, next) => {
    let {
      _id,
      deleteUrl,
    } = event.other

    try {

      await db.collection('products')
        .where({
          _id
        })
        .update({
          data: {
            imgs: _.pull(deleteUrl)
          }
        })

      ctx.body = getSuccessData({
        id,
        deleteUrl
      })

    } catch (error) {

      ctx.body = getFailData({
        msg: "删除照片异常",
        error,
        id,
        deleteUrl
      })

    }

  })

  /**
   * 上传了图片到腾讯云，保存图片的url到后台。
   */
  app.router('/img/urlSave', async (ctx, next) => {
    const {
      _id,
      url
    } = event.other

    try {
      await db.collection("products")
        .doc(_id)
        .update({
          data: {
            imgs: _.push(url)
          }
        })

      ctx.body = getSuccessData()

    } catch (error) {

      ctx.body = getFailData({
        msg: "保存照片异常",
        error
      })

    }

  })


  /**
   * 获取首页中的永昌装饰公司信息
   */
  app.router('/getInfo', async (ctx, next) => {
    try {
      const {
        total
      } = await db.collection("yczs-info")
        .where({}).count()

      if (total > 0) {
        const {
          data
        } = await db.collection("yczs-info")
          .where({}).get()

        ctx.body = getSuccessData(data)
      } else {
        ctx.body = getSuccessData()
      }

    } catch (error) {

      ctx.body = getFailData({
        msg: "获取信息异常",
        error
      })

    }

  })

  /**
   * 更新首页中的永昌装饰公司信息
   */
  app.router('/updateInfo', async (ctx, next) => {
    const {
      address,
      phone,
      info,
      avator,
      bottomImages
    } = event.other

    let data = {}

    if (undefined !== address || null !== address) data.address = address
    if (undefined !== phone || null !== phone) data.phone = phone
    if (undefined !== info || null !== info) data.info = info
    if (undefined !== avator || null !== avator) data.avator = avator
    if (undefined !== bottomImages || null !== bottomImages) data.bottomImages = bottomImages
    if ({} === data) {
      ctx.body = getFailData({
        msg: "请提交更新信息",
      })
      return null;
    }

    try {
      const {
        total
      } = await db.collection("yczs-info").where({}).count()

      if (total > 0) {
        await db.collection("yczs-info")
          .where({
            _id: '2b1d787a5f17a26800025f4a5335bef5'
          })
          .update({
            data
          })
      } else {
        await db.collection("yczs-info").add({
          data
        })
      }

      ctx.body = getSuccessData()

    } catch (error) {

      ctx.body = getFailData({
        msg: "更新信息异常",
        error,
      })

    }

  })

  return app.serve()
}